using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("AttackSpellController")]
	public class AttackSpellController : SpellController
	{
		public HeroAttackDef m_HeroInfo => method_3<HeroAttackDef>("m_HeroInfo");

		public AllyAttackDef m_AllyInfo => method_3<AllyAttackDef>("m_AllyInfo");

		public float m_ImpactStagingPoint => method_2<float>("m_ImpactStagingPoint");

		public float m_SourceImpactOffset => method_2<float>("m_SourceImpactOffset");

		public List<SpellValueRange> m_ImpactDefs => method_3<Class251<SpellValueRange>>("m_ImpactDefs")?.method_25();

		public Spell m_DefaultImpactSpellPrefab => method_3<Spell>("m_DefaultImpactSpellPrefab");

		public static float PROPOSED_ATTACK_IMPACT_POINT_SCALAR => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "AttackSpellController", "PROPOSED_ATTACK_IMPACT_POINT_SCALAR");

		public static float WINDFURY_REMINDER_WAIT_SEC => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "AttackSpellController", "WINDFURY_REMINDER_WAIT_SEC");

		public AttackType m_attackType => method_2<AttackType>("m_attackType");

		public Spell m_sourceAttackSpell => method_3<Spell>("m_sourceAttackSpell");

		public Vector3 m_sourcePos => method_2<Vector3>("m_sourcePos");

		public Vector3 m_sourceToTarget => method_2<Vector3>("m_sourceToTarget");

		public Vector3 m_sourceFacing => method_2<Vector3>("m_sourceFacing");

		public AttackSpellController(IntPtr address, string className)
			: base(address, className)
		{
		}

		public AttackSpellController(IntPtr address)
			: this(address, "AttackSpellController")
		{
		}

		public new bool AddPowerSourceAndTargets(PowerTaskList taskList)
		{
			return method_11<bool>("AddPowerSourceAndTargets", new object[1] { taskList });
		}

		public new void OnProcessTaskList()
		{
			method_8("OnProcessTaskList");
		}

		public void OnSourceAttackStateStarted(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnSourceAttackStateStarted", spell, prevStateType, userData);
		}

		public void LaunchAttack()
		{
			method_8("LaunchAttack");
		}

		public void OnMoveToTargetFinished()
		{
			method_8("OnMoveToTargetFinished");
		}

		public void DoTasks(Card sourceCard, Card targetCard)
		{
			method_8("DoTasks", sourceCard, targetCard);
		}

		public void MoveSourceHeroBack(Card sourceCard)
		{
			method_8("MoveSourceHeroBack", sourceCard);
		}

		public void OrientSourceHeroBack(Card sourceCard)
		{
			method_8("OrientSourceHeroBack", sourceCard);
		}

		public void OnHeroMoveBackFinished()
		{
			method_8("OnHeroMoveBackFinished");
		}

		public void OnHeroSourceAttackStateFinished(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnHeroSourceAttackStateFinished", spell, prevStateType, userData);
		}

		public void OnMinionSourceAttackStateFinished(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnMinionSourceAttackStateFinished", spell, prevStateType, userData);
		}

		public void FinishAttackSpellController()
		{
			method_8("FinishAttackSpellController");
		}

		public void FinishEverything()
		{
			method_8("FinishEverything");
		}

		public bool CanPlayWindfuryReminder(Entity entity, Card card)
		{
			return method_11<bool>("CanPlayWindfuryReminder", new object[2] { entity, card });
		}

		public void PlayWindfuryReminderIfPossible(Entity entity, Card card)
		{
			method_8("PlayWindfuryReminderIfPossible", entity, card);
		}

		public void MoveSourceToTarget(Card sourceCard, Entity sourceEntity, Vector3 impactPos)
		{
			method_8("MoveSourceToTarget", sourceCard, sourceEntity, impactPos);
		}

		public void OrientSourceHeroToTarget(Card sourceCard)
		{
			method_8("OrientSourceHeroToTarget", sourceCard);
		}

		public void MoveTargetToSource(Card targetCard, Entity sourceEntity, Vector3 impactPos)
		{
			method_8("MoveTargetToSource", targetCard, sourceEntity, impactPos);
		}

		public Vector3 ComputeImpactPos()
		{
			return method_11<Vector3>("ComputeImpactPos", Array.Empty<object>());
		}

		public Vector3 ComputeImpactOffset(Card sourceCard, Vector3 impactPos)
		{
			return method_11<Vector3>("ComputeImpactOffset", new object[2] { sourceCard, impactPos });
		}

		public void ActivateImpactEffects(Card sourceCard, Card targetCard)
		{
			method_8("ActivateImpactEffects", sourceCard, targetCard);
		}

		public Spell DetermineImpactSpellPrefab(Card sourceCard)
		{
			return method_14<Spell>("DetermineImpactSpellPrefab", new object[1] { sourceCard });
		}

		public void OnImpactSpellStateFinished(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnImpactSpellStateFinished", spell, prevStateType, userData);
		}
	}
}
